home *** CD-ROM | disk | FTP | other *** search
/ Dr. Windows 3 / dr win3.zip / dr win3 / NEW_TECH / MENTC.ZIP / WORD.C < prev   
C/C++ Source or Header  |  1993-04-18  |  17KB  |  684 lines
  1. /*
  2.  * The routines in this file implement commands that work word or a
  3.  * paragraph at a time.  There are all sorts of word mode commands.  If I
  4.  * do any sentence mode commands, they are likely to be put in this file. 
  5.  */
  6.  
  7. #include    <stdio.h>
  8. #include    "estruct.h"
  9. #include    "eproto.h"
  10. #include    "edef.h"
  11. #include    "elang.h"
  12.  
  13. /* Word wrap on n-spaces. Back-over whatever precedes the point on the current
  14.  * line and stop on the first word-break or the beginning of the line. If we
  15.  * reach the beginning of the line, jump back to the end of the word and start
  16.  * a new line.    Otherwise, break the line at the word-break, eat it, and jump
  17.  * back to the end of the word. Make sure we force the display back to the
  18.  * left edge of the current window
  19.  * Returns TRUE on success, FALSE on errors.
  20.  */
  21. PASCAL NEAR wrapword(f, n)
  22.  
  23. int f;        /* default flag */
  24. int n;        /* numeric argument */
  25.  
  26. {
  27.     register int cnt;    /* size of word wrapped to next line */
  28.     register int c;        /* charector temporary */
  29.  
  30.     /* backup from the <NL> 1 char */
  31.     if (!backchar(FALSE, 1))
  32.         return(FALSE);
  33.  
  34.     /* back up until we aren't in a word,
  35.        make sure there is a break in the line */
  36.     cnt = 0;
  37.     while (((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ')
  38.                 && (c != '\t')) {
  39.         cnt++;
  40.         if (!backchar(FALSE, 1))
  41.             return(FALSE);
  42.         /* if we make it to the beginning, start a new line */
  43.         if (curwp->w_doto == 0) {
  44.             gotoeol(FALSE, 0);
  45.             return(lnewline());
  46.         }
  47.     }
  48.  
  49.     /* delete the forward white space */
  50.     if (!forwdel(0, 1))
  51.         return(FALSE);
  52.  
  53.     /* put in a end of line */
  54.     if (!lnewline())
  55.         return(FALSE);
  56.  
  57.     /* and past the first word */
  58.     while (cnt-- > 0) {
  59.         if (forwchar(FALSE, 1) == FALSE)
  60.             return(FALSE);
  61.     }
  62.  
  63.     /* make sure the display is not horizontally scrolled */
  64.     if (curwp->w_fcol != 0) {
  65.         curwp->w_fcol = 0;
  66.         curwp->w_flag |= WFHARD | WFMOVE | WFMODE;
  67.     }
  68.  
  69.     return(TRUE);
  70. }
  71.  
  72. /*
  73.  * Move the cursor backward by "n" words. All of the details of motion are
  74.  * performed by the "backchar" and "forwchar" routines. Error if you try to
  75.  * move beyond the buffers.
  76.  */
  77. PASCAL NEAR backword(f, n)
  78.  
  79. int f,n;    /* prefix flag and argument */
  80.  
  81. {
  82.     if (n < 0)
  83.         return(forwword(f, -n));
  84.     if (backchar(FALSE, 1) == FALSE)
  85.         return(FALSE);
  86.     while (n--) {
  87.         while (inword() == FALSE) {
  88.             if (backchar(FALSE, 1) == FALSE)
  89.                 return(FALSE);
  90.         }
  91.         while (inword() != FALSE) {
  92.             if (backchar(FALSE, 1) == FALSE)
  93.                 return(FALSE);
  94.         }
  95.     }
  96.     return(forwchar(FALSE, 1));
  97. }
  98.  
  99. /*
  100.  * Move the cursor forward by the specified number of words. All of the motion
  101.  * is done by "forwchar". Error if you try and move beyond the buffer's end.
  102.  */
  103. PASCAL NEAR forwword(f, n)
  104.  
  105. int f,n;    /* prefix flag and argument */
  106.  
  107. {
  108.     if (n < 0)
  109.         return(backword(f, -n));
  110.     while (n--) {
  111.         /* scan through the current word */
  112.         while (inword() == TRUE) {
  113.             if (forwchar(FALSE, 1) == FALSE)
  114.                 return(FALSE);
  115.         }
  116.  
  117.         /* scan through the intervening white space */
  118.         while (inword() == FALSE) {
  119.             if (forwchar(FALSE, 1) == FALSE)
  120.                 return(FALSE);
  121.         }
  122.     }
  123.     return(TRUE);
  124. }
  125.  
  126. /*
  127.  * Move forward to the end of the nth next word. Error if you move past
  128.  * the end of the buffer.
  129.  */
  130. PASCAL NEAR endword(f, n)
  131.  
  132. int f,n;    /* prefix flag and argument */
  133.  
  134. {
  135.     if (n < 0)
  136.         return(backword(f, -n));
  137.     while (n--) {
  138.         /* scan through the intervening white space */
  139.         while (inword() == FALSE) {
  140.             if (forwchar(FALSE, 1) == FALSE)
  141.                 return(FALSE);
  142.         }
  143.  
  144.         /* scan through the current word */
  145.         while (inword() == TRUE) {
  146.             if (forwchar(FALSE, 1) == FALSE)
  147.                 return(FALSE);
  148.         }
  149.     }
  150.     return(TRUE);
  151. }
  152.  
  153. /*
  154.  * Move the cursor forward by the specified number of words. As you move,
  155.  * convert any characters to upper case. Error if you try and move beyond the
  156.  * end of the buffer. Bound to "M-U".
  157.  */
  158. PASCAL NEAR upperword(f, n)
  159.  
  160. int f,n;    /* prefix flag and argument */
  161.  
  162. {
  163.     int c;
  164.  
  165.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if    */
  166.         return(rdonly());    /* we are in read only mode    */
  167.     if (n < 0)
  168.         return(FALSE);
  169.     while (n--) {
  170.         while (inword() == FALSE) {
  171.             if (forwchar(FALSE, 1) == FALSE)
  172.                 return(FALSE);
  173.         }
  174.         while (inword() != FALSE) {
  175.             c = lgetc(curwp->w_dotp, curwp->w_doto);
  176.             if (islowerz(c)) {
  177.                 c = upperc(c);
  178.                 lputc(curwp->w_dotp, curwp->w_doto, c);
  179.                 lchange(WFHARD);
  180.             }
  181.             if (forwchar(FALSE, 1) == FALSE)
  182.                 return(FALSE);
  183.         }
  184.     }
  185.     return(TRUE);
  186. }
  187.  
  188. /*
  189.  * Move the cursor forward by the specified number of words. As you move
  190.  * convert characters to lower case. Error if you try and move over the end of
  191.  * the buffer. Bound to "M-L".
  192.  */
  193. PASCAL NEAR lowerword(f, n)
  194.  
  195. int f,n;    /* prefix flag and argument */
  196.  
  197. {
  198.     int c;
  199.  
  200.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if    */
  201.         return(rdonly());    /* we are in read only mode    */
  202.     if (n < 0)
  203.         return(FALSE);
  204.     while (n--) {
  205.         while (inword() == FALSE) {
  206.             if (forwchar(FALSE, 1) == FALSE)
  207.                 return(FALSE);
  208.         }
  209.         while (inword() != FALSE) {
  210.             c = lgetc(curwp->w_dotp, curwp->w_doto);
  211.             if (isupperz(c)) {
  212.                 c = lowerc(c);
  213.                 lputc(curwp->w_dotp, curwp->w_doto, c);
  214.                 lchange(WFHARD);
  215.             }
  216.             if (forwchar(FALSE, 1) == FALSE)
  217.                 return(FALSE);
  218.         }
  219.     }
  220.     return(TRUE);
  221. }
  222.  
  223. /*
  224.  * Move the cursor forward by the specified number of words. As you move
  225.  * convert the first character of the word to upper case, and subsequent
  226.  * characters to lower case. Error if you try and move past the end of the
  227.  * buffer. Bound to "M-C".
  228.  */
  229. PASCAL NEAR capword(f, n)
  230.  
  231. int f,n;    /* prefix flag and argument */
  232.  
  233. {
  234.     int c;
  235.  
  236.     if (curbp->b_mode&MDVIEW)    /* don't allow this command if    */
  237.         return(rdonly());    /* we are in read only mode    */
  238.     if (n < 0)
  239.         return(FALSE);
  240.     while (n--) {
  241.         while (inword() == FALSE) {
  242.             if (forwchar(FALSE, 1) == FALSE)
  243.                 return(FALSE);
  244.         }
  245.         if (inword() != FALSE) {
  246.             c = lgetc(curwp->w_dotp, curwp->w_doto);
  247.             if (islowerz(c)) {
  248.                 c = upperc(c);
  249.                 lputc(curwp->w_dotp, curwp->w_doto, c);
  250.                 lchange(WFHARD);
  251.             }
  252.             if (forwchar(FALSE, 1) == FALSE)
  253.                 return(FALSE);
  254.             while (inword() != FALSE) {
  255.                 c = lgetc(curwp->w_dotp, curwp->w_doto);
  256.                 if (isupperz(c)) {
  257.                     c = lowerc(c);
  258.                     lputc(curwp->w_dotp, curwp->w_doto, c);
  259.                     lchange(WFHARD);
  260.                 }
  261.                 if (forwchar(FALSE, 1) == FALSE)
  262.                     return(FALSE);
  263.             }
  264.         }
  265.     }
  266.     return(TRUE);
  267. }
  268.  
  269. /*
  270.  * Kill forward by "n" words. Remember the location of dot. Move forward by
  271.  * the right number of words. Put dot back where it was and issue the kill
  272.  * command for the right number of characters. With a zero argument, just
  273.  * kill one word and no whitespace. Bound to "M-D".
  274.  */
  275. PASCAL NEAR delfword(f, n)
  276.  
  277. int f,n;    /* prefix flag and argument */
  278.  
  279. {
  280.     register LINE    *dotp;    /* original cursor line */
  281.     register int    doto;    /*    and row */
  282.     register int c;        /* temp char */
  283.     long size;        /* # of chars to delete */
  284.  
  285.     /* don't allow this command if we are in read only mode */
  286.     if (curbp->b_mode&MDVIEW)
  287.         return(rdonly());
  288.  
  289.     /* ignore the command if there is a negative argument */
  290.     if (n < 0)
  291.         return(FALSE);
  292.  
  293.     /* Clear the kill buffer if last command wasn't a kill */
  294.     if ((lastflag&CFKILL) == 0)
  295.         kdelete();
  296.     thisflag |= CFKILL;    /* this command is a kill */
  297.  
  298.     /* save the current cursor position */
  299.     dotp = curwp->w_dotp;
  300.     doto = curwp->w_doto;
  301.  
  302.     /* figure out how many characters to give the axe */
  303.     size = 0;
  304.  
  305.     /* get us into a word.... */
  306.     while (inword() == FALSE) {
  307.         if (forwchar(FALSE, 1) == FALSE)
  308.             return(FALSE);
  309.         ++size;
  310.     }
  311.  
  312.     if (n == 0) {
  313.         /* skip one word, no whitespace! */
  314.         while (inword() == TRUE) {
  315.             if (forwchar(FALSE, 1) == FALSE)
  316.                 return(FALSE);
  317.             ++size;
  318.         }
  319.     } else {
  320.         /* skip n words.... */
  321.         while (n--) {
  322.     
  323.             /* if we are at EOL; skip to the beginning of the next */
  324.             while (curwp->w_doto == llength(curwp->w_dotp)) {
  325.                 if (forwchar(FALSE, 1) == FALSE)
  326.                     return(FALSE);
  327.                 ++size;
  328.             }
  329.     
  330.             /* move forward till we are at the end of the word */
  331.             while (inword() == TRUE) {
  332.                 if (forwchar(FALSE, 1) == FALSE)
  333.                     return(FAL